/**
 *    Copyright (C) 2008  Victor Smirnov <aist11@gmail.com>
 *
 *    This program is free software; you can redistribute it and/or modify
 *    it under the terms of the GNU General Public License as published by
 *    the Free Software Foundation; either version 3 of the License, or
 *    (at your option) any later version.
 *
 *    This program is distributed in the hope that it will be useful,
 *    but WITHOUT ANY WARRANTY; without even the implied warranty of
 *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *    GNU General Public License for more details.
 *
 *    You should have received a copy of the GNU General Public License along
 *    with this program; if not, write to the Free Software Foundation, Inc.,
 *    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 *    See LICENSE.exceptions in the root folder of this project for possible
 *    exceptions
 *
 */

#ifndef _CUBEFS_CORE_PAGE_MGR_HPP
#define _CUBEFS_CORE_PAGE_MGR_HPP

#include <iostream>
#include <fstream>
#include <map>

#include <cubefs/core/container/container.hpp>


namespace cubefs    {

using namespace std;
using namespace cubefs::ctr;

//template <typename TypeContainerType>
//class SimplePageManager: public AbstractPageManagerLocator<RootProfile>::Type {
//
//    typedef typename AbstractPageManagerLocator<RootProfile>::Type         Base;
//public:
//    typedef typename Base::Page                                                 Page;
//    typedef typename Base::ID                                                   ID;
//    typedef typename Base::Transaction                                          Transaction;
//
//    static const int PAGE_SIZE = Base::PAGE_SIZE;
//
//private:
//    typedef map<ID, Page*>  IDPageMap;
//
//    BigInt                  counter_;
//    IDPageMap               pages_;
//    ContainerMetadata*      metadata_;
//    string                  file_;
//
//public:
//
//    SimplePageManager(): counter_(100), pages_() {
//        metadata_ = TypeContainerType::reflection();
//    }
//
//
//    Transaction *begin() {
//        return new Transaction();
//    }
//
//    void commit(Transaction *txn) {}
//    void rollback(Transaction *txn) {}
//
//    virtual Page* for_update(Page *page) {
//        return page;
//    }
//
//    virtual Page* create_new() {
//        char * buf = new char[4096];
//        for (int c = 0; c < 4096; c++) buf[c] = 0;
//
//        ID id = counter_++;
//
//        Page* p     = new (buf) Page(id);
//        pages_[id]  = p;
//
//        return p;
//    }
//
//    virtual void free(const ID &id) {
//        Page*       page    = pages_[id];
//        char*       buf     = (char*)page;
//        delete[]    buf;
//        pages_.erase(id);
//    }
//
//    virtual void free(Page *page) {
//        free(page->id());
//    }
//
//    virtual Page *get(const ID &page_id) {
//        if (page_id.is_null()) {
//            return NULL;
//        }
//        else {
//            return pages_[page_id];
//        }
//    }
//
//    virtual void sync(const ID &page_id) {
//
//    }
//
//    int get_page_size() {
//        return PAGE_SIZE;
//    }
//
//    void load(const string &file) {
//        this->file_ = file;
//        ifstream f(file.c_str());
//        char buf[PAGE_SIZE];
//
//        BigInt maxId = -1;
//        bool   first = true;
//
//        while (!f.eof())
//        {
//            f.read(buf, PAGE_SIZE);
//
//            Page*   page = (Page*)buf;
//            BigInt  idVal = page->id().value();
//
//            if (idVal > maxId)
//            {
//                maxId = idVal;
//            }
//
//            PageMetadata* pageMetadata = metadata_->GetPageMetadata(page->page_type_hash());
//
//            char* mem = new char[PAGE_SIZE];
//
//            //pageMetadata->Internalize(page, mem);
//
//            pages_[page->id()] = (Page*)mem;
//        }
//
//        f.close();
//
//        counter_ = maxId + 1;
//    }
//
//    void dump() {
//        dump(this->file_);
//    }
//
//    void dump(const string &file) {
//        ofstream f;
//
//        f.open(file.c_str(), ios::trunc | ios::binary);
//
//        char buf[PAGE_SIZE];
//
//        for (IDPageMap::iterator i = pages_.begin(); i!=pages_.end(); i++)
//        {
//            Page *page = i->second;
//
//            if (page->page_type_hash() != 0) {
//
//                BigInt pid = page->id().value();
//
//                PageMetadata* pageMetadata = metadata_->GetPageMetadata(page->page_type_hash());
//                //pageMetadata->Externalize(page, buf);
//
//                f.write(buf, PAGE_SIZE);
//            }
//            else {
//                std::cout<<"hash for page "<<page->id().value()<<" is not specified"<<std::endl;
//            }
//        }
//
//        f.close();
//    }
//};


} //cubefs
#endif
